package org.csu.mypetstore.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.csu.mypetstore.common.CommonResponse;
import org.csu.mypetstore.domain.*;
import org.csu.mypetstore.mapper.*;
import org.csu.mypetstore.service.CartService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;

@Service("cartService")
public class CartServiceImpl implements CartService {
    @Autowired
    private CartMapper cartMapper;
    @Autowired
    private CategoryMapper categoryMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private ItemMapper itemMapper;
    @Autowired
    private AccountMapper accountMapper;

    /*
    接口功能：根据用户id获取该用户对应的购物车列表
    参数：String userId
    返回值：List<Cart>
    错误校验：userId
     */
    @Override
    public CommonResponse<List<Cart>> getCartListByUserId(String userId) {
        // 错误校验：userId
        if(this.userIdValidation(userId)){
            return CommonResponse.createForError("查找错误，Account数据库中没有userId为"+userId+"的用户");
        }

        // 错误校验：userId
        QueryWrapper<Cart> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user", userId);
        List<Cart> cartList = cartMapper.selectList(queryWrapper);
        if (cartList.isEmpty()) {
            return CommonResponse.createForError("查找错误，mycart数据库中没有userId为" + userId + "的Cart");
        }

        for (Cart cart : cartList) {
            String itemId = cart.getItemId();
            cart.setItem(this.getItemById(itemId));
            cart.setProduct(this.getProductByItemId(itemId));
            cart.setCategory(this.getCategoryByItemId(itemId));
        }
        return CommonResponse.createForSuccess(cartList);
    }


    /*
    接口功能：根据用户id和商品id获取该二元组对应的购物车项
    参数：String userId, String itemId
    返回值：Cart
    错误校验：<userId, itemId>
     */
    @Override
    public CommonResponse<Cart> getCartById(String userId, String itemId) {
        // 错误校验：userId
        if(this.userIdValidation(userId)){
            return CommonResponse.createForError("查找错误，Account数据库中没有userId为"+userId+"的用户");
        }

        // 错误校验：itemId
        if(this.itemIdValidation(itemId)){
            return CommonResponse.createForError("查找错误，Item数据库中没有itemId为"+itemId+"的商品");
        }

        // 错误校验：mycart数据库中没有<userId和itemId>
        Cart cart = this.getCartByUserIdAndItemId(userId, itemId);
        if (cart == null) {
            return CommonResponse.createForError("查找错误，数据库中没有userId为" + userId + "的Cart，或，没有itemId为" + itemId + "的Cart");
        }
        cart.setCategory(this.getCategoryByItemId(itemId));
        cart.setProduct(this.getProductByItemId(itemId));
        cart.setItem(this.getItemById(itemId));
        return CommonResponse.createForSuccess(cart);
    }


    /*
    接口功能：根据用户id和itemId在mycart数据库表中添加该Cart购物车项
    参数：String userId, String itemId
    返回值：Integer
    错误校验：userId, itemId, <userId, itemId>
     */
    @Override
    public CommonResponse<Integer> addCart(String userId, String itemId) {
        // 错误校验：数据库中没有user信息
        if(this.userIdValidation(userId)){
            return CommonResponse.createForError("插入错误，Account数据库中没有userId为"+userId+"的用户");
        }

        // 错误校验：数据库中没有item信息
        if(this.itemIdValidation(itemId)){
            return CommonResponse.createForError("插入错误，Item数据库中没有itemId为"+itemId+"的商品");
        }

        // 错误校验：mycart数据库中已经有user信息和item信息了
        Cart flagCart=this.getCartByUserIdAndItemId(userId, itemId);
        if (flagCart != null) {
            return CommonResponse.createForError("插入错误，数据库中已经有了userId为" + userId + "，itemId为" + itemId + "的Cart项");
        }
        Cart cart = new Cart();
        cart.setUserId(userId);
        cart.setItemId(itemId);
        cart.setQuantity(1);// 默认新cart的数量为1
        cart.setItem(this.getItemById(itemId));
        cart.setProduct(this.getProductByItemId(itemId));
        cart.setCategory(this.getCategoryByItemId(itemId));
        int result = cartMapper.insert(cart);
        if (result == 0) {
            return CommonResponse.createForError("插入操作失败");
        }
        return CommonResponse.createForSuccess("插入操作成功，受影响行数为：" + result, result);
    }

    /*
    接口功能：根据用户id与商品id，删除mycart数据库中对应二元组的Cart项
    参数：String userId, String itemId
    返回值：Cart
    错误校验：userId, itemId, <userId, itemId>
     */
    @Override
    public CommonResponse<Integer> deleteCart(String userId, String itemId) {
        // 错误校验：数据库中没有user信息
        if(this.userIdValidation(userId)){
            return CommonResponse.createForError("删除错误，数据库中没有userId为"+userId+"的数据");
        }

        // 错误校验：数据库中没有item信息
        Item item = itemMapper.selectById(itemId);
        if(this.itemIdValidation(itemId)){
            return CommonResponse.createForError("删除错误，数据库中没有itemId为"+itemId+"的数据");
        }

        // 错误校验：数据库中没有user信息和item信息
        Cart cart = this.getCartByUserIdAndItemId(userId, itemId);
        if (cart == null) {
            return CommonResponse.createForError("删除错误，数据库中没有userId为" + userId + "的Cart，或，没有itemId为" + itemId + "的Cart");
        }
        QueryWrapper<Cart> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("iditem", itemId).eq("user", userId);
        int result = cartMapper.delete(queryWrapper);
        if (result == 0) {
            return CommonResponse.createForError("删除操作失败");
        }
        return CommonResponse.createForSuccess("删除操作成功，受影响行数为：" + result, result);
    }

    /*
    接口功能：根据用户id与商品id，按照quantity的要求，修改mycart数据库中对应二元组的Cart项的quantity属性
    参数：String userId, String itemId, int quantity
    返回值：Integer
    错误校验：quantity, userId, itemId, <userId, itemId>
     */
    @Override
    public CommonResponse<Integer> changeCart(String userId, String itemId, int quantity) {
        // 错误校验：输入的quantity非正
        if (quantity <= 0) {
            return CommonResponse.createForError("修改错误，传入的quantity非正，为" + quantity);
        }

        // 错误校验：数据库中没有user信息
        if(this.userIdValidation(userId)){
            return CommonResponse.createForError("修改错误，Account数据库中没有userId为"+userId+"的用户");
        }

        // 错误校验：数据库中没有item信息
        if(this.itemIdValidation(itemId)){
            return CommonResponse.createForError("修改错误，Item数据库中没有itemId为"+itemId+"的商品");
        }

        // 错误校验：数据库中没有<userId, itemId>
        QueryWrapper<Cart> cartQueryWrapper = new QueryWrapper<>();
        cartQueryWrapper.eq("user", userId).eq("iditem", itemId);
        Cart cart = cartMapper.selectOne(cartQueryWrapper);
        if(cart==null){
            return CommonResponse.createForError("修改错误，mycart数据库中没有userId为"+userId+"的用户，或没有itemId为"+itemId+"的商品");
        }

        cart.setQuantity(quantity);
        cart.setItem(this.getItemById(itemId));
        cart.setProduct(this.getProductByItemId(itemId));
        cart.setCategory(this.getCategoryByItemId(itemId));


        int result = cartMapper.update(cart, cartQueryWrapper);
        if (result == 0) {
            return CommonResponse.createForError("更新操作失败");
        }
        return CommonResponse.createForSuccess("更新操作成功，受影响行数为" + result, result);
    }

    @Override
    public BigDecimal getTotalCost(Cart cart) {
        BigDecimal subTotal = new BigDecimal("0");
        BigDecimal quantity = new BigDecimal(String.valueOf(cart.getQuantity()));
        BigDecimal listPrice = cart.getItem().getListPrice();
        subTotal = subTotal.add(listPrice.multiply(quantity));
        return subTotal;
    }

    @Override
    public BigDecimal getSubCost(List<Cart> cartList) {
        BigDecimal subTotal = BigDecimal.valueOf(0);
        if (cartList != null) {
            for (Cart cart : cartList) {
                subTotal = subTotal.add(getTotalCost(cart));
            }
        }
        return subTotal;
    }


    // find back
    private Item getItemById(String itemId) {
        return itemMapper.selectById(itemId);
    }

    private Product getProductByItemId(String itemId) {
        return productMapper.selectById(this.getItemById(itemId).getProductId());
    }

    private Category getCategoryByItemId(String itemId) {
        return categoryMapper.selectById(this.getProductByItemId(itemId).getCategory());
    }

    private Cart getCartByUserIdAndItemId(String userId, String itemId) {
        QueryWrapper<Cart> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user", userId).eq("idItem", itemId);
        return cartMapper.selectOne(queryWrapper);
    }

    /*
    userId验证
    返回：数据库中无用户则返回true，有用户则返回false
     */
    private Boolean userIdValidation(String userId) {
        QueryWrapper<Account> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("userid", userId);
        return accountMapper.selectOne(queryWrapper) == null;
    }

    /*
    itemId验证
    返回：数据库中无商品则返回true，有商品则返回false
     */
    private Boolean itemIdValidation(String itemId) {
        return itemMapper.selectById(itemId) == null;
    }
}
